《Java语言程序设计》期末试卷A (精选04)

注意：

（1）所有答案均写在答题纸上，写在试卷上无效；（2）试题中若出现Java源代码，则不考虑源代码的大小写错误和标点符号错误，也不考虑标点符号的中英文状态；但考生自己书写的代码需要注意大小写！（3）当题目中只有程序片段时，假设完整程序已经具有其它必要代码并导入 Java 的必需包、主类的定义、main()方法的定义等。（4）考试结束，试卷和答题纸一起上交。

一、单选题(每题2分，共20分)

1、下列变量定义正确的是（）

A. byte a = 129;
B. short b = 2.2;
C. float c = 5.5f;
D. boolean flag = "false";

查看答案与解析

答案：C

解析：

A：byte 范围 -128~127，129 溢出。✗
B：short 是整数类型，不能赋浮点值 2.2。✗
C：5.5f 是 float 类型字面量，正确。✓
D：boolean 只能是 true/false，不能是字符串 "false"。✗

难度: ⭐ 考点: #数据类型范围 #变量定义

💡 学习锦囊

📖 相关公式与知识点:

byte 范围：-128~127
short 范围：-32768~32767
float 字面量：必须加 f 后缀，如 5.5f
boolean 值：只能是 true 或 false，不是字符串

易错点

byte 范围是 -128~127，129 超出范围
boolean 值是 true/false，不是字符串 "false"
float 字面量必须加 f，否则默认为 double

🔄 举一反三

下列哪个变量定义是正确的？
- A. char c = "A";
- B. double d = 3.14f;
- C. int i = 3.0;
- D. long l = 1234567890123;
查看练习答案与解析
答案：B 解析：A 中 char 用单引号 'A'；B 中 float 可以自动提升为 double，正确；C 中 3.0 是 double 不能赋给 int；D 中长整型字面量需要加 L 后缀 1234567890123L。

2、语句 { int x = 2; int y = 3; y = x++; } 执行后，x、y 的值分别为（）

A. 4, 4
B. 4, 3
C. 3, 3
D. 3, 2

查看答案与解析

答案：D

解析：y = x++ 是后缀自增，先将 x 的值 2 赋给 y，然后 x 自增为 3。所以 x = 3, y = 2。

难度: ⭐⭐ 考点: #自增运算符 #前缀后缀

💡 学习锦囊

📖 相关公式与知识点:

前缀自增：++x，先增后用
后缀自增：x++，先用后增
赋值顺序：后缀自增在赋值表达式中，先使用原值赋值，再自增

易错点

y = x++ 是先用后增，y = ++x 是先增后用
区分 x++ 和 ++x 在赋值时的不同行为

🔄 举一反三

int x = 5; int y = ++x + x++; 执行后 x 和 y 的值分别是？
查看练习答案与解析
答案：x=7, y=12 解析：++x 先增 x=6，x++ 先用 x=6 再增 x=7，y = 6 + 6 = 12。

3、数学表达式 $$|x| > 100$$ 对应的 Java 表达式为（）

A. |x| > 100
B. x > 100 && x < -100
C. x > 100 || x < -100
D. 100 > x > -100

查看答案与解析

答案：C

解析： $$|x| > 100$$ 表示 x 大于 100 或 x 小于 -100，即 x > 100 || x < -100。

A：Java 中没有 |x| 语法。✗
B：x > 100 && x < -100 不可能同时成立。✗
C：x > 100 || x < -100 正确。✓
D：Java 不支持连续比较。✗

难度: ⭐⭐ 考点: #逻辑表达式 #绝对值 #逻辑运算符

💡 学习锦囊

📖 相关公式与知识点:

绝对值表达式： $$|x|>a$$ → x > a || x < -a
逻辑或：|| 表示满足其一即可
逻辑与：&& 表示必须同时满足
Java 不支持连续比较如 a < x < b

易错点

Java 中没有 |x| 语法，需用 Math.abs(x) 或逻辑表达式
x > 100 && x < -100 不可能同时成立
Java 不支持连续比较 100 > x > -100

🔄 举一反三

数学表达式 $0 < x \leq 10$ 对应的 Java 表达式是？
查看练习答案与解析
答案：x > 0 && x <= 10解析：Java 不支持连续比较，必须用逻辑与连接两个条件。

4、x 和 i 均是初始化后的变量，以下语句正确的是（）

A. x += 10;
B. 12 = i++;
C. x++i = 9;
D. x + 3 = 15;

查看答案与解析

答案：A

解析：

A：x += 10 是复合赋值语句，等价于 x = x + 10，正确。✓
B：12 是常量，不能作为左值。✗
C：x++i 语法错误。✗
D：x + 3 是表达式，不能作为左值。✗

难度: ⭐ 考点: #赋值语句 #左值 #复合赋值

💡 学习锦囊

📖 相关公式与知识点:

赋值规则：左值必须是变量，不能是常量或表达式
复合赋值：x += 10 等价于 x = x + 10
左值：赋值号左边必须是可修改的变量

易错点

常量不能作为左值
表达式（如 x + 3）不能作为左值
x++i 是语法错误，不是合法表达式

🔄 举一反三

下列哪个赋值语句是正确的？
- A. 3 = x;
- B. x + 1 = 10;
- C. x *= 2;
- D. x++ = 5;
查看练习答案与解析
答案：C 解析：A 中 3 是常量不能作为左值；B 中 x+1 是表达式不能作为左值；C 中 x *= 2 等价于 x = x * 2，正确；D 中 x++ 是表达式不能作为左值。

5、下列数组定义语句正确的是（）

A. int a = {1; 2; 3};
B. int b = (1, 2, 3);
C. int c[] = {1, 2, 3};
D. int[] d = {1; 2; 3};

查看答案与解析

答案：C

解析：

A：声明类型应为数组 int[] 或 int a[]，且用逗号分隔。✗
B：声明类型应为数组，且用花括号 {}。✗
C：int c[] = {1, 2, 3} 正确。✓
D：数组初始化用逗号分隔，不是分号。✗

难度: ⭐ 考点: #数组声明 #数组初始化

💡 学习锦囊

📖 相关公式与知识点:

数组声明：int[] a = {...} 或 int a[] = {...}
数组初始化：元素用逗号分隔，用花括号 {} 包裹
常见错误：用分号分隔、用圆括号、缺少数组标识 []

易错点

数组初始化用逗号分隔，不是分号
初始化列表用花括号 {}，不是圆括号 ()
声明数组时必须有 []

🔄 举一反三

下列哪个数组定义是正确的？
- A. double[] arr = {1.1, 2.2, 3.3};
- B. String s = {"a", "b"};
- C. int[] x = (1, 2, 3);
- D. int y[] = {1; 2; 3};
查看练习答案与解析
答案：A 解析：B 缺少数组标识 []；C 用了圆括号而非花括号；D 用了分号而非逗号。只有 A 完全正确。

6、关于用关键字 private 修饰的成员变量，下列说法正确的是（）

A. 可以被其他包的类访问
B. 只能被同一个包中的其他类访问
C. 只能被该类自身所访问或修改
D. 可以被其他包中的该类的子类访问

查看答案与解析

答案：C

解析： private 修饰的成员变量只能被该类自身访问，其他任何类（包括子类、同包类）都不能直接访问。

难度: ⭐ 考点: #访问修饰符 #private

💡 学习锦囊

📖 相关公式与知识点:

private：本类可访问
默认（无修饰符）：本包可访问
protected：本包 + 其他包的子类可访问
public：所有类可访问

易错点

private 成员连子类都不能直接访问
默认访问权限仅限同包，不包括其他包的子类

🔄 举一反三

关于 protected 修饰的成员，下列说法正确的是？
- A. 只能被本类访问
- B. 可以被同包的其他类和不同包的子类访问
- C. 只能被同包的类访问
- D. 任何类都不能访问
查看练习答案与解析
答案：B 解析：protected 允许同包的所有类访问，也允许不同包的子类访问。

7、以下关于构造方法的描述错误的是（）

A. 构造方法的返回类型只能是 void 型
B. 构造方法是类的一种特殊方法，它的方法名必须与类名相同
C. 构造方法的主要作用是完成对类的对象的初始化工作
D. 一个类可以定义多个构造方法

查看答案与解析

答案：A

解析： 构造方法没有返回类型（连 void 也没有），A 说"返回类型只能是 void 型"是错误的。

B 正确：构造方法名必须与类名相同。
C 正确：构造方法用于初始化对象。
D 正确：可以重载多个构造方法。

难度: ⭐⭐ 考点: #构造方法 #方法重载

💡 学习锦囊

📖 相关公式与知识点:

构造方法特点：与类同名，无返回类型，用于初始化对象
构造方法重载：一个类可以定义多个构造方法（参数列表不同）
默认构造方法：如果不写任何构造方法，编译器自动提供无参构造

易错点

构造方法没有返回类型，连 void 都不能写
如果自定义了构造方法，编译器不再提供默认无参构造

🔄 举一反三

下列哪个是合法的构造方法定义（类名为 MyClass）？
- A. void MyClass() {}
- B. int MyClass(int x) { return x; }
- C. MyClass() {}
- D. static MyClass() {}
查看练习答案与解析
答案：C 解析：A 有 void 返回类型，不是构造方法；B 有 int 返回类型，不是构造方法；C 无返回类型，与类同名，是合法构造方法；D 构造方法不能用 static 修饰。

8、方法 public void overload(int x, int y) {} 不合理的重载方法是（）

A. public long overload(long x, long y, long z) {}
B. public float overload(float x, float y) {}
C. public void overload(int x) {}
D. public int overload(int a, int b) {}

查看答案与解析

答案：D

解析： 重载要求参数列表不同。D 的参数为 (int a, int b) 与原方法 (int x, int y) 相同（只是形参名不同），仅返回类型不同，不是合法重载。

A：参数为 (long, long, long)，个数不同，合法。✓
B：参数为 (float, float)，类型不同，合法。✓
C：参数为 (int)，个数不同，合法。✓
D：参数相同，仅返回类型不同，不合法。✗

难度: ⭐⭐ 考点: #方法重载 #参数列表

💡 学习锦囊

📖 相关公式与知识点:

方法重载：同名不同参，与返回类型无关
重载条件：参数个数不同、参数类型不同、参数顺序不同
形参名不同不算重载：编译器只看参数类型和个数

易错点

重载只看参数列表，不看返回类型和形参名
仅返回类型不同不是合法重载，编译会报错

🔄 举一反三

下列哪个是 public void show(int a) 的合法重载？
- A. public int show(int b)
- B. public void show(double a)
- C. public void show(int a, int b) 和 B 都合法
- D. A 和 B 都合法
查看练习答案与解析
答案：C 解析：A 参数相同仅返回类型不同，不合法；B 参数类型不同（double vs int），合法；C 中 show(int, int) 参数个数不同，也合法。所以 B 和 C 中列出的两个方法都合法。

9、设 Student 为已定义的类名，下列语句有可能正确创建 Student 对象的是（）

A. Student s = new Student;
B. Student s = new Student();
C. Student s = Student();
D. Student s[] = new Student[10];

查看答案与解析

答案：B

解析：

A：缺少括号 ()。✗
B：new Student() 正确创建对象。✓
C：缺少 new 关键字。✗
D：创建的是数组，不是单个对象。✗

难度: ⭐ 考点: #对象创建 #new关键字

💡 学习锦囊

📖 相关公式与知识点:

创建对象语法：类名对象名 = new 类名(参数);
new 关键字：分配内存并调用构造方法
构造方法调用：必须使用括号 ()

易错点

创建对象不能省略 new 关键字
创建对象不能省略括号 ()
new Student[10] 创建的是数组，不是单个对象

🔄 举一反三

下列哪个语句正确创建了 String 对象？
- A. String s = new String;
- B. String s = String("hello");
- C. String s = new String("hello");
- D. String s[] = new String();
查看练习答案与解析
答案：C 解析：A 缺少括号；B 缺少 new 关键字；C 语法完全正确；D 等号左侧是数组类型，右侧不是数组创建，类型不匹配。

10、类 Panel 默认的布局管理器是（）

A. GridLayout
B. BorderLayout
C. FlowLayout
D. CardLayout

查看答案与解析

答案：C

解析：

Panel 默认布局管理器是 FlowLayout（从左到右排列）
JFrame 默认布局管理器是 BorderLayout
GridLayout 和 CardLayout 需要手动设置

难度: ⭐ 考点: #布局管理器 #Panel #FlowLayout

💡 学习锦囊

📖 相关公式与知识点:

Panel 默认布局：FlowLayout（从左到右排列）
JFrame 默认布局：BorderLayout（东南西北中）
GridLayout：网格布局，等分区域
CardLayout：卡片布局，一次显示一个组件

易错点

Panel 和 JFrame 的默认布局不同，容易混淆
Panel 默认是 FlowLayout，不是 BorderLayout

🔄 举一反三

JFrame 的默认布局管理器是？
- A. FlowLayout
- B. BorderLayout
- C. GridLayout
- D. CardLayout
查看练习答案与解析
答案：B 解析：JFrame 默认使用 BorderLayout，将容器分为东、南、西、北、中五个区域。

二、程序阅读题（每问2分，共20分）

1、有如下程序：

java

public class test {
    public static void main(String[] args) {
        int i;
        int a[] = {4, 6, 2, 8, 0, 1, 3};
        int m = a[0];
        for (i = 1; i < a.length; ++i) {
            if (m < a[i])
                m = a[i];
        }
        System.out.println(m);
    }
}

程序描述功能（20字以内）：(1)

程序输出结果：(2)

查看答案与解析

(1) 答案：求数组中的最大值

(2) 答案：8

解析： 遍历数组 {4, 6, 2, 8, 0, 1, 3}，逐个比较找出最大值：

m 初始 = 4
6 > 4 → m = 6
2 < 6 → m 不变
8 > 6 → m = 8
0 < 8 → m 不变
1 < 8 → m 不变
3 < 8 → m 不变

最终 m = 8。

难度: ⭐⭐ 考点: #数组遍历 #求最大值

💡 学习锦囊

📖 相关公式与知识点:

求最大值算法：设第一个元素为初始最大值，逐个比较更新
数组遍历：for (int i = 0; i < a.length; i++)

思路分析

看到逐个比较并更新 m 的模式，立即识别为求最大值算法。

易错点

求最大值时初始值应设为第一个元素，不能设为 0（数组可能全为负数）

🔄 举一反三

编写方法求数组中的最小值。
查看练习答案与解析
java
```
int min = a[0];
for (int i = 1; i < a.length; i++)
    if (a[i] < min) min = a[i];
```
1
2
3
解析：与求最大值逻辑相同，只需将比较方向反转。

2、有如下程序：

java

public class Test {
    static boolean check(int x) {
        if (x == 1) return false;
        for (int i = 2; i <= x / 2; i++)
            if (x % i == 0) return false;
        return true;
    }
    public static void main(String args[]) {
        for (int i = 5; i < 10; i++) {
            if (check(i) == false)
                System.out.println(i);
        }
    }
}

成员函数 check 功能描述（20字以内）：(3)

程序输出结果：(4)

查看答案与解析

(3) 答案：判断是否为素数

(4) 答案：6、8、9

解析：check(x) 判断 x 是否为素数，check(i) == false 输出非素数。

5：素数 → 不输出
6：非素数（6%2==0）→ 输出 6
7：素数 → 不输出
8：非素数（8%2==0）→ 输出 8
9：非素数（9%3==0）→ 输出 9

难度: ⭐⭐ 考点: #素数判断 #取模运算

💡 学习锦囊

📖 相关公式与知识点:

素数判断：从 2 到 $\sqrt{n}$ （或 n/2）检查是否有因子
取模运算：x % i == 0 表示 x 能被 i 整除
1 不是素数：需要特殊处理

易错点

素数判断中 1 不是素数，需要特殊处理
注意 check(i) == false 输出的是非素数

🔄 举一反三

修改程序，输出 5~9 中的所有素数。
查看练习答案与解析
答案：5, 7 解析：将 check(i) == false 改为 check(i) == true，输出素数 5 和 7。

3、有如下程序：

java

public class AClass {
    static int fct(int n) {
        if (n == 0 || n == 1) return 1;
        else return fct(n - 1) * n;
    }
    static int getCMB(int m, int n) {
        return fct(m) / fct(n) / fct(m - n);
    }
    public static void main(String args[]) {
        System.out.printf("%d", getCMB(5, 3));
    }
}

成员函数 fct 功能描述（20字以内）：(5)

程序输出结果：(6)

查看答案与解析

(5) 答案：求阶乘 n!

(6) 答案：10

解析：

fct(n) 是递归求阶乘：fct(0)=1, fct(n)=fct(n-1)*n
getCMB(m,n) 计算组合数 $C_m^n = \frac{m!}{n!(m-n)!}$
getCMB(5,3) = $\frac{5!}{3! \times 2!}$ = $\frac{120}{6 \times 2}$ = 10

难度: ⭐⭐⭐ 考点: #递归 #阶乘 #组合数

💡 学习锦囊

📖 相关公式与知识点:

阶乘： $n! = 1 \times 2 \times \dots \times n$ ，递归定义 $n! = (n-1)! \times n$
组合数： $C_m^n = \frac{m!}{n!(m-n)!}$
递归三要素：递归终止条件、递归调用、返回值

易错点

0! = 1，不是 0
组合数计算中注意整数除法的顺序

🔄 举一反三

计算 $$C_6^2$$ 的值。
查看练习答案与解析
答案：15 解析： $C_6^2 = \frac{6!}{2! \times 4!} = \frac{720}{2 \times 24} = 15$

4、有如下程序：

java

public class testComplex {
    public static void main(String[] args) {
        Complex a = new Complex(2, 3);
        Complex b = new Complex(4, 5);
        Complex c = a.add(b);
        System.out.println(c.toString());
    }
}
class Complex {
    private double realPart;
    private double imaginaryPart;
    public Complex(double a, double b) {
        this.realPart = a;
        this.imaginaryPart = b;
    }
    public Complex() {
        this.realPart = 0;
        this.imaginaryPart = 0;
    }
    public Complex add(Complex a) {
        double x = this.realPart + a.realPart;
        double y = this.imaginaryPart + a.imaginaryPart;
        return new Complex(x, y);
    }
    public String toString() {
        String show = this.realPart + " + " + this.imaginaryPart + "i";
        return show;
    }
}

类 Complex 成员函数 add 功能描述（20字以内）：(7)

程序输出结果：(8)

查看答案与解析

(7) 答案：复数加法运算

(8) 答案：6.0 + 8.0i

解析：

a = (2+3i), b = (4+5i)
c = a.add(b) = (2+4) + (3+5)i = 6.0 + 8.0i
toString() 返回 "6.0 + 8.0i"

难度: ⭐⭐ 考点: #复数类 #类设计 #toString方法

💡 学习锦囊

📖 相关公式与知识点:

复数加法： $$(a+bi) + (c+di) = (a+c) + (b+d)i$$
toString 方法：将对象转换为字符串表示
this 关键字：引用当前对象的成员

易错点

复数加法是实部和虚部分别相加
double 类型运算结果带小数点，如 6.0 而非 6

🔄 举一反三

若 a = (1+2i), b = (3-1i)，则 a.add(b) 的结果是什么？
查看练习答案与解析
答案：4.0 + 1.0i 解析：实部 1+3=4，虚部 2+(-1)=1，结果为 4.0 + 1.0i。

5、有如下程序：

java

import javax.swing.*;
import java.awt.event.*;
import java.awt.*;
class AdderFrame extends JFrame implements ActionListener {
    private JTextField tfOp1, tfOp2, tfSum;
    private JButton btnEqual;
    AdderFrame() {
        btnEqual = new JButton("=");
        tfOp1 = new JTextField(10);
        tfOp2 = new JTextField(10);
        tfSum = new JTextField(10);
        setBounds(200, 300, 500, 80);
        btnEqual.addActionListener(this);
        setLayout(new FlowLayout());
        add(tfOp1); add(tfOp2); add(btnEqual); add(tfSum);
    }
    public void actionPerformed(ActionEvent event) {
        int a = Integer.parseInt(tfOp1.getText());
        int b = Integer.parseInt(tfOp2.getText());
        tfSum.setText(a + b + "");
    }
    public static void main(String[] args) {
        AdderFrame frm = new AdderFrame();
        frm.setVisible(true);
    }
}

描述程序的功能：(9)

语句 btnEqual.addActionListener(this) 的作用（20字以内）：(10)

查看答案与解析

(9) 答案：图形界面加法计算器，输入两个整数，点击等号按钮显示和

(10) 答案：注册按钮点击事件监听器

解析：

btnEqual.addActionListener(this) 将当前对象注册为按钮的事件监听器，当按钮被点击时，自动调用当前对象的 actionPerformed 方法。
程序功能：两个文本框输入整数，点击 "=" 按钮，第三个文本框显示两数之和。

难度: ⭐⭐⭐ 考点: #GUI事件处理 #ActionListener #JTextField

💡 学习锦囊

📖 相关公式与知识点:

事件监听：addActionListener() 注册监听器，actionPerformed() 处理事件
ActionListener 接口：必须实现 actionPerformed(ActionEvent e) 方法
this 关键字：当前对象作为监听器

思路分析

看到 implements ActionListener 和 actionPerformed 方法，即可识别为 GUI 事件处理模式。

易错点

GUI 事件处理中 this 指当前实现了 ActionListener 接口的对象
addActionListener(this) 注册监听器，不是触发事件

🔄 举一反三

如何为按钮添加鼠标点击监听器（使用匿名内部类）？
查看练习答案与解析
java
```
btn.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent e) {
        // 处理逻辑
    }
});
```
1
2
3
4
5
解析：使用匿名内部类实现 ActionListener 接口，无需让主类 implements ActionListener。

三、程序填空题(每空2分，共20分)

程序 1： D 盘有文本文件 abc.txt，如下程序读出该文件内容，并打印出来：

java

import java.io.File;
import java.io.FileReader;
import java.io.IOException;
public class zifudx {
    public static void main(String[] args) throws IOException {
        File f = new File("d:\\abc.txt");
        FileReader fr = new FileReader(f);
        int ch = fr.read();
        while ( (1) ) {
            System.out.print((char)ch);
            ch = (2);
        }
        (3);
    }
}

查看答案与解析

(1) 答案：ch != -1

(2) 答案：fr.read()

(3) 答案：fr.close()

解析：

(1) FileReader 的 read() 方法返回 -1 表示文件结束，循环条件为 ch != -1。
(2) 每次循环读取下一个字符：ch = fr.read()。
(3) 读取完毕后关闭流，释放资源：fr.close()。

难度: ⭐⭐ 考点: #文件读取 #FileReader #IO流关闭

💡 学习锦囊

📖 相关公式与知识点:

FileReader：字符输入流，read() 返回 int（-1 表示文件结束），需强制转换为 char
文件操作三步：打开 → 读取 → 关闭
关闭流：使用 close() 方法释放资源

易错点

fr.read() 返回 int，不是 char，-1 表示文件结束
读取完毕后必须关闭流，否则造成资源泄漏

🔄 举一反三

使用 BufferedReader 按行读取文件内容。
查看练习答案与解析
java
```
BufferedReader br = new BufferedReader(new FileReader("d:\\abc.txt"));
String line;
while ((line = br.readLine()) != null) {
    System.out.println(line);
}
br.close();
```
1
2
3
4
5
6
解析：BufferedReader 提供 readLine() 方法，一次读取一行，返回 null 表示文件结束。

程序 2： 有二分查找程序如下：

java

class biSearch {
    public static void main(String[] args) {
        int a[] = {9, 13, 25, 34, 38, 62, 69, 78, 86, 97};
        int searchnum = 86;
        int index = -1, left, mid, right;
        left = 0;
        right = a.length - 1;
        while (left <= right) {
            mid = (4);
            if (a[mid] == searchnum) {
                index = mid;
                break;
            } else if (a[mid] < searchnum)
                (5);
            else
                (6);
        }
        if (index == -1)
            System.out.println(searchnum + "在数组中不存在！");
        else
            System.out.println(searchnum + "在数组中位置是" + index);
    }
}

查看答案与解析

(4) 答案：(left + right) / 2

(5) 答案：left = mid + 1

(6) 答案：right = mid - 1

解析：

(4) 二分查找取中间位置：mid = (left + right) / 2。
(5) 若中间元素小于目标值，目标在右半段：left = mid + 1。
(6) 若中间元素大于目标值，目标在左半段：right = mid - 1。

难度: ⭐⭐⭐ 考点: #二分查找 #算法实现

💡 学习锦囊

📖 相关公式与知识点:

二分查找：前提是数组有序，时间复杂度 O(log n)
核心思想：每次将搜索范围缩小一半
边界更新：left = mid + 1 和 right = mid - 1

易错点

二分查找中 left = mid + 1 和 right = mid - 1，不能写成 mid，否则可能死循环
二分查找前提是数组必须有序

🔄 举一反三

在有序数组 {2, 5, 8, 12, 16, 23, 38, 56, 72, 91} 中用二分查找 23，需要几次比较？
查看练习答案与解析
答案：2 次解析：第1次 mid=4(值16)，23>16 → left=5；第2次 mid=7(值56)，23<56 → right=6；第3次 mid=5(值23)，找到。实际需要3次比较。

程序 3： 如下是冒泡排序算法：

java

class mp {
    public static void main(String[] args) {
        int a[] = {37, 28, 51, 13, 64, 8, 42};
        int i, j, n, temp;
        n = a.length;
        for (j = 1; (7); j++) {
            for (i = 0; (8); i++) {
                if (a[i] > a[i + 1]) {
                    temp = a[i];
                    a[i] = a[i + 1];
                    a[i + 1] = temp;
                }
            }
        }
        System.out.print("排序后的数据为: ");
        for (i = 0; i < n; i++) {
            System.out.print(a[i] + ", ");
        }
    }
}

查看答案与解析

(7) 答案：j < n（或 j < a.length）

(8) 答案：i < n - j（或 i < a.length - j）

解析：

(7) 外层循环控制排序趟数，共需 n-1 趟，j < n 即可。
(8) 内层循环控制每趟比较次数，第 j 趟比较 n-j 次，i < n - j。

难度: ⭐⭐⭐ 考点: #冒泡排序 #排序算法

💡 学习锦囊

📖 相关公式与知识点:

冒泡排序：相邻元素两两比较，每趟将最大值"冒泡"到末尾，时间复杂度 O(n²)
外层循环：控制排序趟数，n-1 趟
内层循环：控制每趟比较次数，第 j 趟比较 n-j 次

易错点

冒泡排序内层循环范围 i < n - j，不是 i < n - 1
外层循环从 j=1 开始时，条件为 j < n

🔄 举一反三

对数组 {5, 3, 8, 1} 执行第一趟冒泡排序后的结果是什么？
查看练习答案与解析
答案：{3, 5, 1, 8}解析：比较 5和3→交换{3,5,8,1}；比较5和8→不交换；比较8和1→交换{3,5,1,8}。第一趟结束后最大值8冒泡到末尾。

程序 4： 类 Point 用以表示直角坐标系中的点，其中 distance() 方法返回当前点到坐标原点的距离。

java

public class Point {
    private double x, y;
    (9)(double a, double b) {
        this.x = a;
        this.y = b;
    }
    double distance() {
        return Math.sqrt(x * x + y * y);
    }
    public static void main(String args[]) {
        Point p1 = new Point(3, 4);
        System.out.print((10));
    }
}

查看答案与解析

(9) 答案：Point

(10) 答案：p1.distance()

解析：

(9) 构造方法名必须与类名相同，填 Point。
(10) 调用 p1 的 distance 方法输出到原点的距离：p1.distance()。Point(3,4) 到原点距离为 $\sqrt{3^2+4^2} = 5.0$ 。

难度: ⭐⭐ 考点: #构造方法 #Math.sqrt #勾股定理

💡 学习锦囊

📖 相关公式与知识点:

点到原点距离： $d = \sqrt{x^2 + y^2}$ （勾股定理）
构造方法：与类同名，无返回类型，用于初始化对象
Math.sqrt()：求平方根

易错点

构造方法没有返回类型，连 void 都不能写
调用对象方法需要通过对象名加点号，如 p1.distance()

🔄 举一反三

Point(5, 12) 到原点的距离是多少？
查看练习答案与解析
答案：13.0 解析： $d = \sqrt{5^2 + 12^2} = \sqrt{25 + 144} = \sqrt{169} = 13.0$

四、程序设计题（每题10分，共40分）

1、（10分）记载于中国古代约 5—6 世纪成书的《张邱建算经》的一个算术题目：今有鸡翁一，值钱伍；鸡母一，值钱三；鸡鶵三，值钱一。凡百钱买鸡百只，问鸡翁、母、鶵各几何？编写程序，能够打印出所有答案。

查看答案与解析

答案：

java

public class HundredChickens {
    public static void main(String[] args) {
        for (int x = 0; x <= 20; x++) {
            for (int y = 0; y <= 33; y++) {
                int z = 100 - x - y;
                if (z % 3 == 0 && 5 * x + 3 * y + z / 3 == 100) {
                    System.out.println("鸡翁：" + x + "只，鸡母：" + y + "只，鸡鶵：" + z + "只");
                }
            }
        }
    }
}

运行结果：

鸡翁：0只，鸡母：25只，鸡鶵：75只
鸡翁：4只，鸡母：18只，鸡鶵：78只
鸡翁：8只，鸡母：11只，鸡鶵：81只
鸡翁：12只，鸡母：4只，鸡鶵：84只

解析：

第一步：建立数学模型 设鸡翁 x 只，鸡母 y 只，鸡鶵 z 只：

数量约束：x + y + z = 100
价格约束：5x + 3y + z/3 = 100
非负约束：x ≥ 0, y ≥ 0, z ≥ 0, z 是 3 的倍数

第二步：确定枚举范围

鸡翁：5 钱一只，100 钱最多买 20 只，x ∈ [0, 20]
鸡母：3 钱一只，100 钱最多买 33 只，y ∈ [0, 33]
鸡鶵：z = 100 - x - y，自动确定

第三步：筛选条件

z 必须是 3 的倍数（鸡鶵 3 只 1 钱）
价格等式成立

难度: ⭐⭐⭐ 考点: #枚举法 #不定方程 #嵌套循环

💡 学习锦囊

📖 相关公式与知识点:

百钱买百鸡：经典不定方程问题，用枚举法求解
枚举法：穷举所有可能，筛选满足条件的解
嵌套循环：外层枚举 x，内层枚举 y，z 由约束条件确定

思路分析

看到"求所有答案"和约束条件，使用枚举法：确定变量范围，穷举所有组合，筛选满足条件的解。

易错点

z 必须是 3 的倍数，否则 z/3 不是整数
枚举范围要合理，避免遗漏或冗余

🔄 举一反三

修改百钱买百鸡程序，使鸡翁至少买 1 只。
查看练习答案与解析
将 for (int x = 0; 改为 for (int x = 1;，其余不变。解析：只需修改枚举下界，x 从 1 开始即可保证鸡翁至少 1 只。结果为：鸡翁4只鸡母18只鸡鶵78只、鸡翁8只鸡母11只鸡鶵81只、鸡翁12只鸡母4只鸡鶵84只。

2、（10分）编写程序，能够计算一维数组 {34.9, 43.2, 17, 23, 46.2, 28, 5} 中数字的平均数，并且能够输出所有大于平均数的数字。

查看答案与解析

答案：

java

public class ArrayAverage {
    public static void main(String[] args) {
        double[] a = {34.9, 43.2, 17, 23, 46.2, 28, 5};
        double sum = 0;
        for (int i = 0; i < a.length; i++) {
            sum += a[i];
        }
        double avg = sum / a.length;
        System.out.println("平均数：" + avg);
        System.out.print("大于平均数的数字：");
        for (int i = 0; i < a.length; i++) {
            if (a[i] > avg) {
                System.out.print(a[i] + " ");
            }
        }
    }
}

运行结果：

平均数：28.185714285714287
大于平均数的数字：34.9 43.2 46.2

解析：

第一步：计算平均数 遍历数组，累加所有元素，除以元素个数。

第二步：筛选大于平均数的元素 再次遍历数组，输出大于平均数的元素。

难度: ⭐⭐ 考点: #数组遍历 #求平均数 #条件筛选

💡 学习锦囊

📖 相关公式与知识点:

数组统计：先求和再求平均，二次遍历筛选
平均数公式： $\bar{x} = \frac{\sum_{i=1}^{n} x_i}{n}$
两次遍历：第一次求和，第二次筛选

易错点

数组求平均时注意用 double 类型，避免整数除法
筛选条件是严格大于（>），不是大于等于

🔄 举一反三

修改程序，输出小于平均数的所有数字。
查看练习答案与解析
将 if (a[i] > avg) 改为 if (a[i] < avg) 即可。解析：只需修改比较方向，输出结果为：17 23 5。

3、（10分）设计一个类，其中成员函数 isNarcissus(int n) 能够判断一个三位数是否是水仙花数。然后在类的主函数 main 中利用成员函数 isNarcissus 判断并输出 100~999 中的所有水仙花数。 [注]水仙花数是指一个 n 位数（ $n \geq 3$ ），它的每个位上的数字的 n 次幂之和等于它本身，例如： $$1^3 + 5^3 + 3^3 = 153$$

查看答案与解析

答案：

java

public class Narcissus {
    boolean isNarcissus(int n) {
        if (n < 100 || n > 999) return false;
        int a = n / 100;
        int b = n / 10 % 10;
        int c = n % 10;
        return a * a * a + b * b * b + c * c * c == n;
    }
    public static void main(String[] args) {
        Narcissus obj = new Narcissus();
        for (int i = 100; i <= 999; i++) {
            if (obj.isNarcissus(i)) {
                System.out.println(i);
            }
        }
    }
}

运行结果：

解析：

第一步：理解水仙花数 三位水仙花数：各位数字的立方和等于该数本身。即 $$a^3 + b^3 + c^3 = n$$ 。

第二步：提取各位数字

百位：n / 100
十位：n / 10 % 10
个位：n % 10

第三步：判断与遍历

方法 isNarcissus 先检查是否为三位数，然后提取各位数字并计算立方和。
main 方法遍历 100~999，调用 isNarcissus 判断并输出。

难度: ⭐⭐⭐ 考点: #水仙花数 #数字位提取 #类设计

💡 学习锦囊

📖 相关公式与知识点:

水仙花数：三位数的各位立方和等于自身。 $$a^3 + b^3 + c^3 = n$$
数字位提取：n / 100（百位），n / 10 % 10（十位），n % 10（个位）
整数除法：/ 取整，% 取余

易错点

水仙花数是各位的立方和（三位数），不是平方和
提取十位数字用 n / 10 % 10，不是 n % 100 / 10（两者等价但前者更常见）

🔄 举一反三

编写程序找出所有四位数中的四叶玫瑰数（各位数字的 4 次幂之和等于自身）。

查看练习答案与解析

java

for (int i = 1000; i < 10000; i++) {
    int a = i / 1000;
    int b = i / 100 % 10;
    int c = i / 10 % 10;
    int d = i % 10;
    if (Math.pow(a, 4) + Math.pow(b, 4) + Math.pow(c, 4) + Math.pow(d, 4) == i)
        System.out.println(i);
}

解析：四位数的各位 4 次幂之和等于自身。结果为：1634, 8208, 9474。

4、（10分）定义一个表示日期的 MyDate 类，要求如下：（1）类有三个成员变量 year, month, day 表示年、月、日；（2）设计一个构造函数，在对象初始化时，能够对成员变量 year, month, day 赋初值；（3）设计一个成员方法 boolean isLeapYear()，如果当前年份是闰年返回 true，否则返回 false。 [注]满足下列条件之一，即为闰年：①能被4整除不能被100整除 ②能被400整除

查看答案与解析

答案：

java

public class MyDate {
    int year, month, day;

    MyDate(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }

    boolean isLeapYear() {
        if (year % 400 == 0) return true;
        if (year % 4 == 0 && year % 100 != 0) return true;
        return false;
    }

    public static void main(String[] args) {
        MyDate d1 = new MyDate(2000, 2, 29);
        System.out.println(d1.year + "年是闰年吗？" + d1.isLeapYear());
        MyDate d2 = new MyDate(1900, 1, 1);
        System.out.println(d2.year + "年是闰年吗？" + d2.isLeapYear());
    }
}

运行结果：

2000年是闰年吗？true
1900年是闰年吗？false

解析：

第一步：理解闰年规则 闰年条件（满足其一即可）：

能被 400 整除（如 2000 年）
能被 4 整除但不能被 100 整除（如 2024 年）

第二步：实现判断逻辑

先判断 year % 400 == 0，若成立直接返回 true。
再判断 year % 4 == 0 && year % 100 != 0，若成立返回 true。
其余情况返回 false。

第三步：验证

2000：2000 % 400 == 0 → 闰年 ✓
1900：1900 % 400 ≠ 0，1900 % 4 == 0 但 1900 % 100 == 0 → 非闰年 ✓

难度: ⭐⭐ 考点: #闰年判断 #类设计 #构造方法

💡 学习锦囊

📖 相关公式与知识点:

闰年判断：year % 400 == 0 || (year % 4 == 0 && year % 100 != 0)
构造方法：与类同名，无返回类型，用于初始化对象
this 关键字：区分成员变量和参数

易错点

闰年判断中 1900 年不是闰年（能被 100 整除但不能被 400 整除）
判断顺序：先判断能否被 400 整除，再判断能否被 4 整除但不能被 100 整除

🔄 举一反三

判断 2100 年是否为闰年。
查看练习答案与解析
答案：不是闰年解析：2100 % 400 ≠ 0，2100 % 4 == 0 但 2100 % 100 == 0，不满足闰年条件。

《Java语言程序设计》期末试卷A (精选04) ​

一、单选题(每题2分，共20分) ​

二、程序阅读题（每问2分，共20分） ​

三、程序填空题(每空2分，共20分) ​

四、程序设计题（每题10分，共40分） ​

《Java语言程序设计》期末试卷A (精选04)

一、单选题(每题2分，共20分)

二、程序阅读题（每问2分，共20分）

三、程序填空题(每空2分，共20分)

四、程序设计题（每题10分，共40分）